home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / zcie.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-04-24  |  19.8 KB  |  628 lines
  1. /* Copyright (C) 1992, 1995, 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* zcie.c */
  20. /* CIE color operators */
  21. #include "math_.h"
  22. #include "memory_.h"
  23. #include "ghost.h"
  24. #include "errors.h"
  25. #include "oper.h"
  26. #include "gsstruct.h"
  27. #include "gxcspace.h"        /* gscolor2.h requires gscspace.h */
  28. #include "gscolor2.h"
  29. #include "gscie.h"
  30. #include "estack.h"
  31. #include "ialloc.h"
  32. #include "idict.h"
  33. #include "idparam.h"
  34. #include "igstate.h"
  35. #include "icie.h"
  36. #include "isave.h"
  37. #include "ivmspace.h"
  38. #include "store.h"        /* for make_null */
  39.  
  40. /* CIE color dictionaries are so complex that */
  41. /* we handle the CIE case of setcolorspace separately here. */
  42.  
  43. /* Forward references */
  44. private int cache_common(P4(gs_cie_common *, const ref_cie_procs *,
  45.   void *, const gs_state *));
  46.  
  47. /* Allocator structure types for CIE structures */
  48. private_st_cie_defg();
  49. private_st_cie_def();
  50. private_st_cie_abc();
  51. private_st_cie_a();
  52.  
  53. /* Empty procedures */
  54. static ref empty_procs[4];
  55.  
  56. /* Original CIE color space types. */
  57. /* We use CIExxx rather than CIEBasedxxx in some places because */
  58. /* gcc under VMS only retains 23 characters of procedure names, */
  59. /* and DEC C truncates all identifiers at 31 characters. */
  60. extern const gs_color_space_type
  61.     gs_color_space_type_CIEDEFG,
  62.     gs_color_space_type_CIEDEF,
  63.     gs_color_space_type_CIEABC,
  64.     gs_color_space_type_CIEA;
  65. /* Redefined CIE color space types (that load the cache when installed) */
  66. gs_color_space_type
  67.     cs_type_zCIEDEFG,
  68.     cs_type_zCIEDEF,
  69.     cs_type_zCIEABC,
  70.     cs_type_zCIEA;
  71. private cs_proc_install_cspace(cs_install_zCIEDEFG);
  72. private cs_proc_install_cspace(cs_install_zCIEDEF);
  73. private cs_proc_install_cspace(cs_install_zCIEABC);
  74. private cs_proc_install_cspace(cs_install_zCIEA);
  75.  
  76. /* Initialization */
  77. private void
  78. zcie_init(void)
  79. {
  80.     /* Make the null (default) transformation procedures. */
  81.     make_empty_const_array(&empty_procs[0], a_readonly + a_executable);
  82.     make_empty_const_array(&empty_procs[1], a_readonly + a_executable);
  83.     make_empty_const_array(&empty_procs[2], a_readonly + a_executable);
  84.     make_empty_const_array(&empty_procs[3], a_readonly + a_executable);
  85.  
  86.     /* Create the modified color space types. */
  87.     cs_type_zCIEDEFG = gs_color_space_type_CIEDEFG;
  88.     cs_type_zCIEDEFG.install_cspace = cs_install_zCIEDEFG;
  89.     cs_type_zCIEDEF = gs_color_space_type_CIEDEF;
  90.     cs_type_zCIEDEF.install_cspace = cs_install_zCIEDEF;
  91.     cs_type_zCIEABC = gs_color_space_type_CIEABC;
  92.     cs_type_zCIEABC.install_cspace = cs_install_zCIEABC;
  93.     cs_type_zCIEA = gs_color_space_type_CIEA;
  94.     cs_type_zCIEA.install_cspace = cs_install_zCIEA;
  95.  
  96. }
  97.  
  98. /* ------ Parameter extraction utilities ------ */
  99.  
  100. /* Get a range array parameter from a dictionary. */
  101. /* We know that count <= 4. */
  102. int
  103. dict_ranges_param(const ref *pdref, const char _ds *kstr, int count,
  104.   gs_range *prange)
  105. {    int code = dict_float_array_param(pdref, kstr, count * 2,
  106.                       (float *)prange, NULL);
  107.     if ( code < 0 )
  108.       return code;
  109.     else if ( code == 0 )
  110.       memcpy(prange, Range4_default.ranges, count * sizeof(gs_range));
  111.     else if ( code != count * 2 )
  112.       return_error(e_rangecheck);
  113.     return 0;
  114. }
  115.  
  116. /* Get an array of procedures from a dictionary. */
  117. /* We know count <= countof(empty_procs). */
  118. int
  119. dict_proc_array_param(const ref *pdict, const char _ds *kstr,
  120.   uint count, ref *pparray)
  121. {    ref *pvalue;
  122.     if ( dict_find_string(pdict, kstr, &pvalue) > 0 )
  123.     {    uint i;
  124.         check_array_only(*pvalue);
  125.         if ( r_size(pvalue) != count )
  126.           return_error(e_rangecheck);
  127.         for ( i = 0; i < count; i++ )
  128.         {    ref proc;
  129.             array_get(pvalue, (long)i, &proc);
  130.             check_proc_only(proc);
  131.         }
  132.         *pparray = *pvalue;
  133.     }
  134.     else
  135.         make_const_array(pparray, a_readonly | avm_foreign,
  136.                  count, &empty_procs[0]);
  137.     return 0;
  138. }
  139.         
  140. /* Get WhitePoint and BlackPoint values. */
  141. int
  142. cie_points_param(const ref *pdref, gs_cie_wb *pwb)
  143. {    int code;
  144.     if ( (code = dict_float_array_param(pdref, "WhitePoint", 3, (float *)&pwb->WhitePoint, NULL)) != 3 ||
  145.          (code = dict_float_array_param(pdref, "BlackPoint", 3, (float *)&pwb->BlackPoint, (const float *)&BlackPoint_default)) != 3
  146.        )
  147.       return (code < 0 ? code : gs_note_error(e_rangecheck));
  148.     if ( pwb->WhitePoint.u <= 0 ||
  149.          pwb->WhitePoint.v != 1 ||
  150.          pwb->WhitePoint.w <= 0 ||
  151.          pwb->BlackPoint.u < 0 ||
  152.          pwb->BlackPoint.v < 0 ||
  153.          pwb->BlackPoint.w < 0
  154.        )
  155.       return_error(e_rangecheck);
  156.     return 0;
  157. }
  158.  
  159. /* Process a 3- or 4-dimensional lookup table from a dictionary. */
  160. /* The caller has set pclt->n and pclt->m. */
  161. /* ptref is known to be a readable array of size at least n+1. */
  162. private int cie_3d_table_param(P4(const ref *ptable, uint count, uint nbytes,
  163.   gs_const_string *strings));
  164. int
  165. cie_table_param(const ref *ptref, gx_color_lookup_table *pclt,
  166.   gs_memory_t *mem)
  167. {    int n = pclt->n, m = pclt->m;
  168.     const ref *pta = ptref->value.const_refs;
  169.     int i;
  170.     uint nbytes;
  171.     int code;
  172.     gs_const_string *table;
  173.  
  174.     for ( i = 0; i < n; ++i )
  175.       { check_type_only(pta[i], t_integer);
  176.         if ( pta[i].value.intval <= 1 || pta[i].value.intval > max_ushort )
  177.           return_error(e_rangecheck);
  178.         pclt->dims[i] = (int)pta[i].value.intval;
  179.       }
  180.     nbytes = m * pclt->dims[n-2] * pclt->dims[n-1];
  181.     if ( n == 3 )
  182.       { /* gs_alloc_byte_array is ****** WRONG ****** */
  183.         table =
  184.           (gs_const_string *)gs_alloc_byte_array(mem, pclt->dims[0],
  185.                              sizeof(gs_const_string),
  186.                              "cie_table_param");
  187.         if ( table == 0 )
  188.           return_error(e_VMerror);
  189.         code = cie_3d_table_param(pta + 3, pclt->dims[0], nbytes,
  190.                       table);
  191.       }
  192.     else            /* n == 4 */
  193.       { int d0 = pclt->dims[0], d1 = pclt->dims[1];
  194.         uint ntables = d0 * d1;
  195.         const ref *psuba;
  196.         check_read_type(pta[4], t_array);
  197.         if ( r_size(pta + 4) != d0 )
  198.           return_error(e_rangecheck);
  199.         /* gs_alloc_byte_array is ****** WRONG ****** */
  200.         table =
  201.           (gs_const_string *)gs_alloc_byte_array(mem, ntables,
  202.                              sizeof(gs_const_string),
  203.                              "cie_table_param");
  204.         if ( table == 0 )
  205.           return_error(e_VMerror);
  206.         psuba = pta[4].value.const_refs;
  207.         for ( i = 0; i < d0; ++i )
  208.           { code = cie_3d_table_param(psuba + i, d1, nbytes,
  209.                       table + d1 * i);
  210.         if ( code < 0 )
  211.           break;
  212.           }
  213.       }
  214.     if ( code < 0 )
  215.       { gs_free_object(mem, table, "cie_table_param");
  216.         return code;
  217.       }
  218.     pclt->table = table;
  219.     return 0;
  220. }
  221. private int
  222. cie_3d_table_param(const ref *ptable, uint count, uint nbytes,
  223.   gs_const_string *strings)
  224. {    const ref *rstrings;
  225.     uint i;
  226.  
  227.     check_read_type(*ptable, t_array);
  228.     if ( r_size(ptable) != count )
  229.       return_error(e_rangecheck);
  230.     rstrings = ptable->value.const_refs;
  231.     for ( i = 0; i < count; ++i )
  232.       { const ref *prt2 = rstrings + i;
  233.         check_read_type(*prt2, t_string);
  234.         if ( r_size(prt2) != nbytes )
  235.           return_error(e_rangecheck);
  236.         strings[i].data = rstrings[i].value.const_bytes;
  237.         strings[i].size = nbytes;
  238.       }
  239.     return 0;
  240. }
  241.  
  242. /* ------ CIE setcolorspace ------ */
  243.  
  244. /* Common code for the CIEBased* cases of setcolorspace. */
  245. private int
  246. cie_lmnp_param(const ref *pdref, gs_cie_common *pcie, ref_cie_procs *pcprocs)
  247. {    int code;
  248.     if ( (code = dict_range3_param(pdref, "RangeLMN", &pcie->RangeLMN)) < 0 ||
  249.          (code = dict_proc3_param(pdref, "DecodeLMN", &pcprocs->DecodeLMN)) < 0 ||
  250.          (code = dict_matrix3_param(pdref, "MatrixLMN", &pcie->MatrixLMN)) != matrix3_ok ||
  251.          (code = cie_points_param(pdref, &pcie->points)) < 0
  252.        )
  253.       return (code < 0 ? code : gs_note_error(e_rangecheck));
  254.     pcie->DecodeLMN = DecodeLMN_default;
  255.     return 0;
  256. }
  257.  
  258. /* Common code for the CIEBasedABC/DEF[G] cases of setcolorspace. */
  259. private int
  260. cie_abc_param(const ref *pdref, gs_cie_abc_common *pcie,
  261.   ref_cie_procs *pcprocs)
  262. {    int code;
  263.     if ( (code = dict_range3_param(pdref, "RangeABC", &pcie->RangeABC)) < 0 ||
  264.          (code = dict_proc3_param(pdref, "DecodeABC", &pcprocs->Decode.ABC)) < 0 ||
  265.          (code = dict_matrix3_param(pdref, "MatrixABC", &pcie->MatrixABC)) != matrix3_ok ||
  266.          (code = cie_lmnp_param(pdref, &pcie->common, pcprocs)) < 0
  267.        )
  268.       return (code < 0 ? code : gs_note_error(e_rangecheck));
  269.     pcie->DecodeABC = DecodeABC_default;
  270.     return 0;
  271. }
  272.  
  273. /* Finish setting a CIE space. */
  274. private int
  275. set_cie_finish(os_ptr op, gs_color_space *pcs, const ref_cie_procs *pcprocs)
  276. {    ref_colorspace cspace_old;
  277.     uint edepth = ref_stack_count(&e_stack);
  278.     int code;
  279.  
  280.     /* The color space installation procedure may refer to */
  281.     /* istate->colorspace.procs. */
  282.     cspace_old = istate->colorspace;
  283.     istate->colorspace.procs.cie = *pcprocs;
  284.     code = gs_setcolorspace(igs, pcs);
  285.     if ( code < 0 )
  286.     {    istate->colorspace = cspace_old;
  287.         ref_stack_pop_to(&e_stack, edepth);
  288.         return code;
  289.     }
  290.     pop(1);
  291.     return (ref_stack_count(&e_stack) == edepth ? 0 : o_push_estack);  /* installation will load the caches */
  292. }
  293.  
  294. #ifdef NEW_CIE            /**************** ****************/
  295.  
  296. /* <dict> .setciedefgspace - */
  297. private int
  298. zsetciedefgspace(register os_ptr op)
  299. {    gs_memory_t *mem = gs_state_memory(igs);
  300.     gs_color_space cs;
  301.     ref_color_procs procs;
  302.     gs_cie_defg *pcie;
  303.     int code;
  304.     ref *ptref;
  305.  
  306.     check_type(*op, t_dictionary);
  307.     check_dict_read(*op);
  308.     procs = istate->colorspace.procs;
  309.     rc_alloc_struct_0(pcie, gs_cie_defg, &st_cie_defg, mem,
  310.               return_error(e_VMerror),
  311.               "setcolorspace(CIEBasedDEFG)");
  312.     if ( (code = dict_find_string(op, "Table", &ptref)) <= 0 )
  313.       return (code < 0 ? code : gs_note_error(e_rangecheck));
  314.     check_read_type(*ptref, t_array);
  315.     if ( r_size(ptref) != 5 )
  316.       return_error(e_rangecheck);
  317.     pcie->Table.n = 4;
  318.     pcie->Table.m = 3;
  319.     if ( (code = dict_ranges_param(op, "RangeDEFG", 4, pcie->RangeDEFG.ranges)) < 0 ||
  320.          (code = dict_proc_array_param(op, "DecodeDEFG", 4, &procs.cie.PreDecode.DEFG)) < 0 ||
  321.          (code = dict_ranges_param(op, "RangeHIJK", 4, pcie->RangeHIJK.ranges)) < 0 ||
  322.          (code = cie_table_param(ptref, &pcie->Table, mem)) < 0 ||
  323.          (code = cie_abc_param(op, &pcie->abc, &procs.cie)) < 0
  324.        )
  325.     {    rc_free_struct(pcie, mem, "setcolorspace(CIEBasedDEFG)");
  326.         return code;
  327.     }
  328.     cs.params.defg = pcie;
  329.     cs.type = &cs_type_zCIEDEFG;
  330.     return set_cie_finish(op, &cs, &procs.cie);
  331. }
  332.  
  333. /* <dict> .setciedefspace - */
  334. private int
  335. zsetciedefspace(register os_ptr op)
  336. {    gs_memory_t *mem = gs_state_memory(igs);
  337.     gs_color_space cs;
  338.     ref_color_procs procs;
  339.     gs_cie_def *pcie;
  340.     int code;
  341.     ref *ptref;
  342.  
  343.     check_type(*op, t_dictionary);
  344.     check_dict_read(*op);
  345.     procs = istate->colorspace.procs;
  346.     rc_alloc_struct_0(pcie, gs_cie_def, &st_cie_def, mem,
  347.               return_error(e_VMerror),
  348.               "setcolorspace(CIEBasedDEF)");
  349.     if ( (code = dict_find_string(op, "Table", &ptref)) <= 0 )
  350.       return (code < 0 ? code : gs_note_error(e_rangecheck));
  351.     check_read_type(*ptref, t_array);
  352.     if ( r_size(ptref) != 4 )
  353.       return_error(e_rangecheck);
  354.     pcie->Table.n = 4;
  355.     pcie->Table.m = 3;
  356.     if ( (code = dict_range3_param(op, "RangeDEF", &pcie->RangeDEF)) < 0 ||
  357.          (code = dict_proc3_param(op, "DecodeDEF", &procs.cie.PreDecode.DEF)) < 0 ||
  358.          (code = dict_range3_param(op, "RangeHIJ", &pcie->RangeHIJ)) < 0 ||
  359.          (code = cie_table_param(ptref, &pcie->Table, mem)) < 0 ||
  360.          (code = cie_abc_param(op, &pcie->abc, &procs.cie)) < 0
  361.        )
  362.     {    rc_free_struct(pcie, mem, "setcolorspace(CIEBasedDEF)");
  363.         return code;
  364.     }
  365.     cs.params.def = pcie;
  366.     cs.type = &cs_type_zCIEDEF;
  367.     return set_cie_finish(op, &cs, &procs.cie);
  368. }
  369.  
  370. #endif /*NEW_CIE*/        /**************** ****************/
  371.  
  372. /* <dict> .setcieabcspace - */
  373. private int
  374. zsetcieabcspace(register os_ptr op)
  375. {    gs_memory_t *mem = gs_state_memory(igs);
  376.     gs_color_space cs;
  377.     ref_color_procs procs;
  378.     gs_cie_abc *pcie;
  379.     int code;
  380.  
  381.     check_type(*op, t_dictionary);
  382.     check_dict_read(*op);
  383.     procs = istate->colorspace.procs;
  384.     rc_alloc_struct_0(pcie, gs_cie_abc, &st_cie_abc, mem,
  385.               return_error(e_VMerror),
  386.               "setcolorspace(CIEBasedABC)");
  387.     code = cie_abc_param(op, pcie, &procs.cie);
  388.     if ( code < 0 )
  389.     {    rc_free_struct(pcie, "setcolorspace(CIEBasedABC)");
  390.         return code;
  391.     }
  392.     cs.params.abc = pcie;
  393.     cs.type = &cs_type_zCIEABC;
  394.     return set_cie_finish(op, &cs, &procs.cie);
  395. }
  396.  
  397. /* <dict> .setcieaspace - */
  398. private int
  399. zsetcieaspace(register os_ptr op)
  400. {    gs_memory_t *mem = gs_state_memory(igs);
  401.     gs_color_space cs;
  402.     ref_color_procs procs;
  403.     gs_cie_a *pcie;
  404.     int code;
  405.  
  406.     check_type(*op, t_dictionary);
  407.     check_dict_read(*op);
  408.     procs = istate->colorspace.procs;
  409.     if ( (code = dict_proc_param(op, "DecodeA", &procs.cie.Decode.A, true)) < 0 )
  410.       return code;
  411.     rc_alloc_struct_0(pcie, gs_cie_a, &st_cie_a, mem,
  412.               return_error(e_VMerror),
  413.               "setcolorspace(CIEBasedA)");
  414.     if ( (code = dict_float_array_param(op, "RangeA", 2, (float *)&pcie->RangeA, (const float *)&RangeA_default)) != 2 ||
  415.          (code = dict_float_array_param(op, "MatrixA", 3, (float *)&pcie->MatrixA, (const float *)&MatrixA_default)) != 3 ||
  416.          (code = cie_lmnp_param(op, &pcie->common, &procs.cie)) < 0
  417.        )
  418.     {    rc_free_struct(pcie, "setcolorspace(CIEBasedA)");
  419.         return (code < 0 ? code : gs_note_error(e_rangecheck));
  420.     }
  421.     pcie->DecodeA = DecodeA_default;
  422.     cs.params.a = pcie;
  423.     cs.type = &cs_type_zCIEA;
  424.     return set_cie_finish(op, &cs, &procs.cie);
  425. }
  426.  
  427. /* ------ Install a CIE-based color space. ------ */
  428.  
  429. /* The new CIEBasedDEF[G] spaces aren't really implemented yet.... */
  430. private int
  431. cs_install_zCIEDEFG(gs_color_space *pcs, gs_state *pgs)
  432. {    return_error(e_undefined);
  433. }
  434. private int
  435. cs_install_zCIEDEF(gs_color_space *pcs, gs_state *pgs)
  436. {    return_error(e_undefined);
  437. }
  438.  
  439. private int cie_abc_finish(P1(os_ptr));
  440. private int
  441. cs_install_zCIEABC(gs_color_space *pcs, gs_state *pgs)
  442. {    es_ptr ep = esp;
  443.     gs_cie_abc *pcie = pcs->params.abc;
  444.     const int_gstate *pigs = gs_int_gstate(pgs);
  445.     const ref_cie_procs *pcprocs = &pigs->colorspace.procs.cie;
  446.     int code =
  447.       (*gs_color_space_type_CIEABC.install_cspace)(pcs, pgs);    /* former routine */
  448.     if ( code < 0 ||
  449.          (code = cie_cache_joint(&pigs->colorrendering.procs, pgs)) < 0 ||    /* do this last */
  450.          (code = cie_cache_push_finish(cie_abc_finish, pgs, pcie)) < 0 ||
  451. #ifdef NEW_CIE
  452.          (code = cie_prepare_cache3(&pcie->abc.RangeABC, pcprocs->Decode.ABC.value.const_refs, &pcie->abc.caches.DecodeABC[0], pcie, pgs, "Decode.ABC")) < 0 ||
  453.          (code = cache_common(&pcie->abc.common, pcprocs, pcie, pgs)) < 0
  454. #else
  455.          (code = cie_prepare_cache3(&pcie->RangeABC, pcprocs->Decode.ABC.value.const_refs, &pcie->caches.DecodeABC[0], pcie, pgs, "Decode.ABC")) < 0 ||
  456.          (code = cache_common(&pcie->common, pcprocs, pcie, pgs)) < 0
  457. #endif
  458.        )
  459.     {    esp = ep;
  460.         return code;
  461.     }
  462.     return o_push_estack;
  463. }
  464. private int
  465. cie_abc_finish(os_ptr op)
  466. {    gs_cie_abc_complete(r_ptr(op, gs_cie_abc));
  467.     pop(1);
  468.     return 0;
  469. }
  470.  
  471. private int cie_a_finish(P1(os_ptr));
  472. private int
  473. cs_install_zCIEA(gs_color_space *pcs, gs_state *pgs)
  474. {    es_ptr ep = esp;
  475.     gs_cie_a *pcie = pcs->params.a;
  476.     const int_gstate *pigs = gs_int_gstate(pgs);
  477.     const ref_cie_procs *pcprocs = &pigs->colorspace.procs.cie;
  478.     int code =
  479.       (*gs_color_space_type_CIEA.install_cspace)(pcs, pgs);    /* former routine */
  480.     if ( code < 0 ||
  481.          (code = cie_cache_joint(&pigs->colorrendering.procs, pgs)) < 0 ||    /* do this last */
  482.          (code = cie_cache_push_finish(cie_a_finish, pgs, pcie)) < 0 ||
  483.          (code = cie_prepare_cache(&pcie->RangeA, &pcprocs->Decode.A, &pcie->caches.DecodeA.floats, pcie, pgs, "Decode.A")) < 0 ||
  484.          (code = cache_common(&pcie->common, pcprocs, pcie, pgs)) < 0
  485.        )
  486.     {    esp = ep;
  487.         return code;
  488.     }
  489.     return o_push_estack;
  490. }
  491. private int
  492. cie_a_finish(os_ptr op)
  493. {    gs_cie_a_complete(r_ptr(op, gs_cie_a));
  494.     pop(1);
  495.     return 0;
  496. }
  497.  
  498. /* Common cache code */
  499. private int
  500. cache_common(gs_cie_common *pcie, const ref_cie_procs *pcprocs,
  501.   void *container, const gs_state *pgs)
  502. {    return cie_prepare_cache3(&pcie->RangeLMN,
  503.                   pcprocs->DecodeLMN.value.const_refs,
  504.                   &pcie->caches.DecodeLMN[0], container, pgs,
  505.                   "Decode.LMN");
  506. }
  507.  
  508. /* ------ Internal routines ------ */
  509.  
  510. /* Prepare to cache the values for one or more procedures. */
  511. private int cie_cache_finish(P1(os_ptr));
  512. int
  513. cie_prepare_cache(const gs_range *domain, const ref *proc,
  514.   cie_cache_floats *pcache, void *container, const gs_state *pgs,
  515.   client_name_t cname)
  516. {    int space = imemory_space((gs_ref_memory_t *)gs_state_memory(pgs));
  517.     gs_for_loop_params flp;
  518.     register es_ptr ep;
  519.  
  520.     check_estack(9);
  521.     ep = esp;
  522.     gs_cie_cache_init(&pcache->params, &flp, domain, cname);
  523.     pcache->params.is_identity = r_size(proc) == 0;
  524.     make_real(ep + 9, flp.init);
  525.     make_real(ep + 8, flp.step);
  526.     make_real(ep + 7, flp.limit);
  527.     ep[6] = *proc;
  528.     r_clear_attrs(ep + 6, a_executable);
  529.     make_op_estack(ep + 5, zcvx);
  530.     make_op_estack(ep + 4, zfor);
  531.     make_op_estack(ep + 3, cie_cache_finish);
  532.     /*
  533.      * The caches are embedded in the middle of other
  534.      * structures, so we represent the pointer to the cache
  535.      * as a pointer to the container plus an offset.
  536.      */
  537.     make_int(ep + 2, (char *)pcache - (char *)container);
  538.     make_struct(ep + 1, space, container);
  539.     esp += 9;
  540.     return o_push_estack;
  541. }
  542. private int
  543. cie_prepare_caches(const gs_range *domains, const ref *procs,
  544.   cie_cache_floats **ppc, int count, void *container, const gs_state *pgs,
  545.   client_name_t cname)
  546. {    int i, code = 0;
  547.     for ( i = 0; i < count; ++i )
  548.       if ( (code = cie_prepare_cache(domains + i, procs + i, ppc[i],
  549.                      container, pgs, cname)) < 0
  550.          )
  551.         return code;
  552.     return code;
  553. }
  554. int
  555. cie_prepare_caches_3(const gs_range3 *domains, const ref *procs,
  556.   cie_cache_floats *pc0, cie_cache_floats *pc1, cie_cache_floats *pc2,
  557.   void *container, const gs_state *pgs, client_name_t cname)
  558. {    cie_cache_floats *pc3[3];
  559.     pc3[0] = pc0, pc3[1] = pc1, pc3[2] = pc2;
  560.     return cie_prepare_caches((const gs_range *)domains, procs, pc3, 3,
  561.                   container, pgs, cname);
  562. }
  563.  
  564. /* Store the result of caching one procedure. */
  565. private int
  566. cie_cache_finish(os_ptr op)
  567. {    cie_cache_floats *pcache;
  568.     int code;
  569.     check_esp(2);
  570.     /* See above for the container + offset representation of */
  571.     /* the pointer to the cache. */
  572.     pcache = (cie_cache_floats *)(r_ptr(esp - 1, char) + esp->value.intval);
  573.     code = num_params(op, gx_cie_cache_size, &pcache->values[0]);
  574.     if_debug3('c', "[c]cache 0x%lx base=%g, factor=%g:\n",
  575.           (ulong)pcache, pcache->params.base, pcache->params.factor);
  576.     if ( code < 0 )
  577.       {    /* We might have underflowed the current stack block. */
  578.         /* Handle the parameters one-by-one. */
  579.         uint i;
  580.         for ( i = 0; i < gx_cie_cache_size; i++ )
  581.           {    code = real_param(ref_stack_index(&o_stack,
  582.                         gx_cie_cache_size - 1 - i),
  583.                       &pcache->values[i]);
  584.             if ( code < 0 )
  585.               return code;
  586.           }
  587.       }
  588. #ifdef DEBUG
  589.     if ( gs_debug_c('c') )
  590.     {    int i;
  591.         for ( i = 0; i < gx_cie_cache_size; i += 4 )
  592.           dprintf5("[c]  cache[%3d]=%g, %g, %g, %g\n", i,
  593.                pcache->values[i], pcache->values[i + 1],
  594.                pcache->values[i + 2], pcache->values[i + 3]);
  595.     }
  596. #endif
  597.     ref_stack_pop(&o_stack, gx_cie_cache_size);
  598.     esp -= 2;            /* pop pointer to cache */
  599.     return o_pop_estack;
  600. }
  601.  
  602. /* Push a finishing procedure on the e-stack. */
  603. /* ptr will be the top element of the o-stack. */
  604. int
  605. cie_cache_push_finish(int (*proc)(P1(os_ptr)), gs_state *pgs, void *ptr)
  606. {    check_estack(2);
  607.     push_op_estack(proc);
  608.     ++esp;
  609.     make_struct(esp, imemory_space((gs_ref_memory_t *)gs_state_memory(pgs)), ptr);
  610.     return o_push_estack;
  611. }
  612.  
  613. /* ------ Initialization procedure ------ */
  614.  
  615. BEGIN_OP_DEFS(zcie_l2_op_defs) {
  616.         op_def_begin_level2(),
  617.     {"1.setcieaspace", zsetcieaspace},
  618.     {"1.setcieabcspace", zsetcieabcspace},
  619. #ifdef NEW_CIE
  620.     {"1.setciedefspace", zsetciedefspace},
  621.     {"1.setciedefgspace", zsetciedefgspace},
  622. #endif
  623.         /* Internal operators */
  624.     {"1%cie_abc_finish", cie_abc_finish},
  625.     {"1%cie_a_finish", cie_a_finish},
  626.     {"0%cie_cache_finish", cie_cache_finish},
  627. END_OP_DEFS(zcie_init) }
  628.